// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_LIBPLATFORM_DEFAULT_FOREGROUND_TASK_RUNNER_H_
#define V8_LIBPLATFORM_DEFAULT_FOREGROUND_TASK_RUNNER_H_

#include <queue>

#include "include/libplatform/libplatform.h"
#include "include/v8-platform.h"
#include "src/base/platform/condition-variable.h"
#include "src/base/platform/mutex.h"

namespace v8 {
namespace platform {

    class V8_PLATFORM_EXPORT DefaultForegroundTaskRunner
        : public NON_EXPORTED_BASE(TaskRunner) {
    public:
        using TimeFunction = double (*)();

        DefaultForegroundTaskRunner(IdleTaskSupport idle_task_support,
            TimeFunction time_function);

        void Terminate();

        std::unique_ptr<Task> PopTaskFromQueue(MessageLoopBehavior wait_for_work);

        std::unique_ptr<IdleTask> PopTaskFromIdleQueue();

        void WaitForTaskLocked(const base::MutexGuard&);

        double MonotonicallyIncreasingTime();

        // v8::TaskRunner implementation.
        void PostTask(std::unique_ptr<Task> task) override;

        void PostDelayedTask(std::unique_ptr<Task> task,
            double delay_in_seconds) override;

        void PostIdleTask(std::unique_ptr<IdleTask> task) override;

        bool IdleTasksEnabled() override;

    private:
        // The same as PostTask, but the lock is already held by the caller. The
        // {guard} parameter should make sure that the caller is holding the lock.
        void PostTaskLocked(std::unique_ptr<Task> task, const base::MutexGuard&);

        // A caller of this function has to hold {lock_}. The {guard} parameter should
        // make sure that the caller is holding the lock.
        std::unique_ptr<Task> PopTaskFromDelayedQueueLocked(const base::MutexGuard&);

        bool terminated_ = false;
        base::Mutex lock_;
        base::ConditionVariable event_loop_control_;
        std::queue<std::unique_ptr<Task>> task_queue_;
        IdleTaskSupport idle_task_support_;
        std::queue<std::unique_ptr<IdleTask>> idle_task_queue_;

        // Some helper constructs for the {delayed_task_queue_}.
        using DelayedEntry = std::pair<double, std::unique_ptr<Task>>;
        // Define a comparison operator for the delayed_task_queue_ to make sure
        // that the unique_ptr in the DelayedEntry is not accessed in the priority
        // queue. This is necessary because we have to reset the unique_ptr when we
        // remove a DelayedEntry from the priority queue.
        struct DelayedEntryCompare {
            bool operator()(const DelayedEntry& left, const DelayedEntry& right) const
            {
                return left.first > right.first;
            }
        };
        std::priority_queue<DelayedEntry, std::vector<DelayedEntry>,
            DelayedEntryCompare>
            delayed_task_queue_;

        TimeFunction time_function_;
    };

} // namespace platform
} // namespace v8
#endif // V8_LIBPLATFORM_DEFAULT_FOREGROUND_TASK_RUNNER_H_
